use swc_common::FilePathMapping;
use swc_common::{source_map::SourceMap, sync::Lrc, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_codegen::Config;
use swc_ecma_codegen::{text_writer::JsWriter, Emitter};
use regex::Regex;

// pub fn emit(body: Vec<ModuleItem>) -> String {
//     let module = Module {
//         span: DUMMY_SP,
//         body,
//         shebang: None,
//     };

//     let cm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
//     let mut buf = vec![];
//     let mut emitter = Emitter {
//         cm: cm.clone(),
//         comments: None,
//         wr: JsWriter::new(cm, "\n", &mut buf, None),
//         cfg: Config::default()
//             .with_target(EsVersion::Es2022)
//             .with_omit_last_semi(true),
//     };

//     emitter.emit_module(&module).unwrap();

//     String::from_utf8_lossy(&buf).to_string()
// }

pub fn emit(body: Vec<ModuleItem>) -> String {
    let module = Module {
        span: DUMMY_SP, // DUMMY_SP 来自 swc_common
        body,
        shebang: None,
    };

    let cm = Lrc::new(SourceMap::new(FilePathMapping::empty())); // Lrc, SourceMap, FilePathMapping 来自 swc_common
    let mut buf = vec![];
    let mut emitter = Emitter {
        cm: cm.clone(),
        comments: None, // 假设不需要注释，或注释处理在其他地方
        wr: JsWriter::new(cm, "\n", &mut buf, None), // cm 直接传递，因为 Lrc<SourceMap> 实现了 SourceMap trait
        cfg: Config::default()
            .with_target(EsVersion::Es2022) // EsVersion 通常来自 swc_ecma_ast
            .with_omit_last_semi(true),
    };

    emitter.emit_module(&module).unwrap(); // 生成代码到 buf

    let mut output_code = String::from_utf8_lossy(&buf).to_string(); // 从 buffer 获取字符串形式的代码

    // 在此处进行替换，将 TypeScript 的 `bigint` 关键字替换为 `BigInt` 类型引用
    // 但在Verifier类中保持 bigint 不变
    
    // 首先找到所有Verifier类的范围
    let mut verifier_ranges = Vec::new();
    
    // 使用更精确的方法来找到Verifier类的范围
    let verifier_start_regex = Regex::new(r"export class \$\w*Verifier[^{]*\{").expect("Failed to compile verifier start regex");
    
    for mat in verifier_start_regex.find_iter(&output_code) {
        let class_start = mat.start();
        let body_start = mat.end() - 1; // 大括号的位置
        
        // 找到匹配的结束大括号
        let mut brace_count = 1;
        let mut pos = body_start + 1;
        let chars: Vec<char> = output_code.chars().collect();
        
        while pos < chars.len() && brace_count > 0 {
            match chars[pos] {
                '{' => brace_count += 1,
                '}' => brace_count -= 1,
                _ => {}
            }
            pos += 1;
        }
        
        if brace_count == 0 {
            verifier_ranges.push((class_start, pos));
        }
    }
    
    // 使用正则表达式确保只替换作为完整单词的 "bigint"，但排除Verifier类中的
    let re = Regex::new(r"\bbigint\b").expect("Failed to compile bigint regex");
    let mut result = String::new();
    let mut last_end = 0;
    
    for mat in re.find_iter(&output_code) {
        let start = mat.start();
        let end = mat.end();
        
        // 检查这个匹配是否在Verifier类中
        let in_verifier = verifier_ranges.iter().any(|(v_start, v_end)| start >= *v_start && end <= *v_end);
        
        // 添加匹配前的内容
        result.push_str(&output_code[last_end..start]);
        
        // 如果在Verifier类中，保持原样；否则替换为BigInt
        if in_verifier {
            result.push_str("bigint");
        } else {
            result.push_str("BigInt");
        }
        
        last_end = end;
    }
    
    // 添加剩余的内容
    result.push_str(&output_code[last_end..]);
    output_code = result;

    output_code // 返回修改后的代码字符串
}